---
title: "语法对比与映射"
description: "学习 JavaScript 语法如何映射到 Kotlin 语法，包括变量、函数、控制结构和集合"
---

# 语法对比与映射

欢迎来到 JavaScript 到 Kotlin 转换的第一个模块！在本模块中，我们将探索 JavaScript 语法如何映射到 Kotlin 语法，帮助你理解这两种语言之间的基本差异和相似之处。

## 学习目标

通过本模块的学习，你将能够：
- 理解 JavaScript 变量声明如何映射到 Kotlin
- 将 JavaScript 函数转换为 Kotlin 函数
- 将 JavaScript 控制结构映射到 Kotlin 等价结构
- 使用 Kotlin 的类型系统和空安全
- 有效使用 Kotlin 集合
- 应用 Kotlin 的简洁语法模式

## 变量声明和类型系统

### JavaScript 变量 vs Kotlin 变量

在 JavaScript 中，你使用 `let`、`const` 和 `var` 进行变量声明。Kotlin 有更明确的类型系统，使用 `val`（不可变）和 `var`（可变）。

<UniversalEditor title="变量声明对比" compare={true}>
```javascript !! js
// JavaScript 变量声明
let name = "LangShift";
const age = 25;
var isActive = true;

// JavaScript 带类型注解（TypeScript 风格）
let message: string = "Hello";
const count: number = 42;
```

```kotlin !! kt
// Kotlin 变量声明
val name = "LangShift"  // 类型推断为 String
var age = 25           // 类型推断为 Int
val isActive = true    // 类型推断为 Boolean

// Kotlin 显式类型注解
val message: String = "Hello"
var count: Int = 42
```
</UniversalEditor>

### 主要差异

1. **不可变性**：Kotlin 中的 `val` 类似于 JavaScript 中的 `const`，但 `val` 可以在运行时赋值一次，之后不能再更改。`const` 必须在编译时赋值。
2. **类型推断**：Kotlin 可以推断类型，但你也可以显式指定它们
3. **空安全**：Kotlin 有内置的空安全，而 JavaScript 没有

<UniversalEditor title="空安全对比" compare={true}>
```javascript !! js
// JavaScript - 没有空安全
let user = null;
let name = user.name; // 运行时错误！

// JavaScript 可选链操作符
let name = user?.name; // 安全访问
```

```kotlin !! kt
// Kotlin - 内置空安全
val user: String? = null
// val name = user.name // 编译错误！

// Kotlin 安全调用操作符
val name = user?.name // 安全访问，如果 user 为 null 则返回 null

// Kotlin 非空断言
val name = user!!.name // 如果 user 为 null 则抛出异常
```
</UniversalEditor>

## 函数声明

### JavaScript 函数 vs Kotlin 函数

JavaScript 有多种声明函数的方式，而 Kotlin 有更一致的方法。

<UniversalEditor title="函数声明对比" compare={true}>
```javascript !! js
// JavaScript 函数声明
function greet(name) {
    return "Hello, " + name + "!";
}

// 箭头函数
const greetArrow = (name) => {
    return "Hello, " + name + "!";
};

// 带隐式返回的箭头函数
const greetShort = name => "Hello, " + name + "!";

// 带默认参数的函数
function greetWithDefault(name = "World") {
    return "Hello, " + name + "!";
}
```

```kotlin !! kt
// Kotlin 函数声明
fun greet(name: String): String {
    return "Hello, $name!"
}

// Kotlin 表达式体函数
fun greetShort(name: String) = "Hello, $name!"

// Kotlin 带默认参数的函数
fun greetWithDefault(name: String = "World"): String {
    return "Hello, $name!"
}

// Kotlin lambda 表达式
val greetLambda: (String) -> String = { name -> "Hello, $name!" }
```
</UniversalEditor>

### 函数重载

Kotlin 支持函数重载，而 JavaScript 没有原生支持。

<UniversalEditor title="函数重载" compare={true}>
```javascript !! js
// JavaScript - 没有原生重载
function add(a, b) {
    if (typeof a === 'string' && typeof b === 'string') {
        return a + b;
    }
    return a + b;
}

// 不同签名需要不同方法
function addNumbers(a, b) {
    return a + b;
}

function addStrings(a, b) {
    return a + b;
}
```

```kotlin !! kt
// Kotlin 函数重载
fun add(a: Int, b: Int): Int {
    return a + b
}

fun add(a: String, b: String): String {
    return a + b
}

fun add(a: Double, b: Double): Double {
    return a + b
}

// 使用
val result1 = add(5, 3)        // 调用 Int 版本
val result2 = add("Hello", "World") // 调用 String 版本
val result3 = add(3.14, 2.86)  // 调用 Double 版本
```
</UniversalEditor>

## 控制结构

### If 语句

两种语言都有相似的 if 语句，但 Kotlin 的 if 是表达式。

<UniversalEditor title="If 语句对比" compare={true}>
```javascript !! js
// JavaScript if 语句
let age = 18;
let status;

if (age >= 18) {
    status = "adult";
} else {
    status = "minor";
}

// JavaScript 三元操作符
let status2 = age >= 18 ? "adult" : "minor";
```

```kotlin !! kt
// Kotlin if 表达式
val age = 18
val status = if (age >= 18) {
    "adult"
} else {
    "minor"
}

// Kotlin if 作为表达式（不需要三元操作符）
val status2 = if (age >= 18) "adult" else "minor"
```
</UniversalEditor>

### When 表达式（Kotlin）vs Switch 语句（JavaScript）

Kotlin 的 `when` 比 JavaScript 的 `switch` 更强大。

<UniversalEditor title="When vs Switch 对比" compare={true}>
```javascript !! js
// JavaScript switch 语句
let day = "Monday";
let message;

switch (day) {
    case "Monday":
        message = "Start of work week";
        break;
    case "Friday":
        message = "TGIF!";
        break;
    default:
        message = "Regular day";
}

// JavaScript 带贯穿
switch (day) {
    case "Monday":
    case "Tuesday":
    case "Wednesday":
    case "Thursday":
    case "Friday":
        message = "Work day";
        break;
    default:
        message = "Weekend";
}
```

```kotlin !! kt
// Kotlin when 表达式
val day = "Monday"
val message = when (day) {
    "Monday" -> "Start of work week"
    "Friday" -> "TGIF!"
    else -> "Regular day"
}

// Kotlin when 带多个条件
val message2 = when (day) {
    "Monday", "Tuesday", "Wednesday", "Thursday", "Friday" -> "Work day"
    else -> "Weekend"
}

// Kotlin when 带范围
val number = 5
val result = when (number) {
    in 1..5 -> "Small number"
    in 6..10 -> "Medium number"
    else -> "Large number"
}
```
</UniversalEditor>

### 循环

Kotlin 的循环语法比 JavaScript 更简洁。

<UniversalEditor title="循环对比" compare={true}>
```javascript !! js
// JavaScript for 循环
for (let i = 0; i < 5; i++) {
    console.log(i);
}

// JavaScript for...of 循环
const items = ["apple", "banana", "orange"];
for (const item of items) {
    console.log(item);
}

// JavaScript forEach
items.forEach(item => console.log(item));

// JavaScript while 循环
let count = 0;
while (count < 5) {
    console.log(count);
    count++;
}
```

```kotlin !! kt
// Kotlin for 循环
for (i in 0..4) {
    println(i)
}

// Kotlin for 带范围
for (i in 0 until 5) {
    println(i)
}

// Kotlin for 带步长
for (i in 0..10 step 2) {
    println(i)
}

// Kotlin for 带集合
val items = listOf("apple", "banana", "orange")
for (item in items) {
    println(item)
}

// Kotlin forEach
items.forEach { item -> println(item) }

// Kotlin while 循环
var count = 0
while (count < 5) {
    println(count)
    count++
}
```
</UniversalEditor>

## 集合

### 数组和列表

JavaScript 数组更灵活，而 Kotlin 有不同类型的集合用于不同用例。

<UniversalEditor title="集合对比" compare={true}>
```javascript !! js
// JavaScript 数组
let numbers = [1, 2, 3, 4, 5];
let fruits = ["apple", "banana"];

// 添加元素
numbers.push(6);
fruits.push("orange");

// 删除元素
numbers.pop();
fruits.splice(1, 1);

// 数组方法
let doubled = numbers.map(x => x * 2);
let evenNumbers = numbers.filter(x => x % 2 === 0);
let sum = numbers.reduce((acc, x) => acc + x, 0);

// 数组解构
let [first, second, ...rest] = numbers;
```

```kotlin !! kt
// Kotlin 列表
val numbers = listOf(1, 2, 3, 4, 5)
val fruits = mutableListOf("apple", "banana")

// 添加元素（可变列表）
fruits.add("orange")

// 删除元素
fruits.removeAt(1)

// 列表操作
val doubled = numbers.map { it * 2 }
val evenNumbers = numbers.filter { it % 2 == 0 }
val sum = numbers.reduce { acc, x -> acc + x }

// 列表解构
val (first, second, *rest) = numbers

// Kotlin 数组
val numberArray = arrayOf(1, 2, 3, 4, 5)
val stringArray = arrayOf("hello", "world")
```
</UniversalEditor>

### 映射和对象

JavaScript 对象类似于 Kotlin 映射，但语法不同。

<UniversalEditor title="映射和对象对比" compare={true}>
```javascript !! js
// JavaScript 对象
let person = {
    name: "John",
    age: 30,
    city: "New York"
};

// 访问属性
console.log(person.name);
console.log(person["age"]);

// 添加属性
person.job = "Developer";

// 对象解构
let { name, age } = person;

// JavaScript Map
let userMap = new Map();
userMap.set("id", 1);
userMap.set("name", "Alice");
userMap.set("email", "alice@example.com");

console.log(userMap.get("name"));
```

```kotlin !! kt
// Kotlin 映射
val person = mapOf(
    "name" to "John",
    "age" to 30,
    "city" to "New York"
)

// 访问值
println(person["name"])
println(person["age"])

// 可变映射
val mutablePerson = mutableMapOf(
    "name" to "John",
    "age" to 30
)

// 添加条目
mutablePerson["job"] = "Developer"

// 映射解构
for ((key, value) in person) {
    println("$key: $value")
}

// Kotlin 数据类（比映射更适合结构化数据）
data class Person(
    val name: String,
    val age: Int,
    val city: String
)

val john = Person("John", 30, "New York")
println(john.name)
```
</UniversalEditor>

## 字符串模板和插值

Kotlin 的字符串模板比 JavaScript 的模板字面量更强大。

<UniversalEditor title="字符串模板对比" compare={true}>
```javascript !! js
// JavaScript 模板字面量
let name = "World";
let greeting = `Hello, ${name}!`;

// JavaScript 带表达式
let a = 5;
let b = 3;
let result = `Sum: ${a + b}`;

// JavaScript 带函数调用
function getGreeting(name) {
    return `Hello, ${name}!`;
}

let message = getGreeting("Alice");
```

```kotlin !! kt
// Kotlin 字符串模板
val name = "World"
val greeting = "Hello, $name!"

// Kotlin 带表达式
val a = 5
val b = 3
val result = "Sum: ${a + b}"

// Kotlin 带函数调用
fun getGreeting(name: String) = "Hello, $name!"

val message = getGreeting("Alice")

// Kotlin 带复杂表达式
val items = listOf("apple", "banana", "orange")
val itemList = "Items: ${items.joinToString(", ")}"
```
</UniversalEditor>

## 练习题目

### 练习 1：将 JavaScript 函数转换为 Kotlin

将这个 JavaScript 函数转换为 Kotlin：

```javascript
function calculateTotal(items) {
    let total = 0;
    for (let item of items) {
        total += item.price * item.quantity;
    }
    return total;
}
```

<UniversalEditor title="练习 1 解答" compare={true}>
```javascript !! js
function calculateTotal(items) {
    let total = 0;
    for (let item of items) {
        total += item.price * item.quantity;
    }
    return total;
}

// 使用
const items = [
    { name: "Apple", price: 1.50, quantity: 3 },
    { name: "Banana", price: 0.75, quantity: 2 }
];
console.log(calculateTotal(items));
```

```kotlin !! kt
fun calculateTotal(items: List<Item>): Double {
    var total = 0.0
    for (item in items) {
        total += item.price * item.quantity
    }
    return total
}

// 数据类用于结构化数据
data class Item(
    val name: String,
    val price: Double,
    val quantity: Int
)

// 使用
val items = listOf(
    Item("Apple", 1.50, 3),
    Item("Banana", 0.75, 2)
)
println(calculateTotal(items))
```
</UniversalEditor>

### 练习 2：将 JavaScript 数组操作转换为 Kotlin

将这些 JavaScript 数组操作转换为 Kotlin：

```javascript
const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const evenSquares = numbers
    .filter(n => n % 2 === 0)
    .map(n => n * n)
    .reduce((sum, n) => sum + n, 0);
```

<UniversalEditor title="练习 2 解答" compare={true}>
```javascript !! js
const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const evenSquares = numbers
    .filter(n => n % 2 === 0)
    .map(n => n * n)
    .reduce((sum, n) => sum + n, 0);

console.log(evenSquares); // 220
```

```kotlin !! kt
val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val evenSquares = numbers
    .filter { it % 2 == 0 }
    .map { it * it }
    .reduce { sum, n -> sum + n }

println(evenSquares) // 220
```
</UniversalEditor>

## 关键要点

1. **类型安全**：Kotlin 提供编译时类型检查，而 JavaScript 是动态类型
2. **空安全**：Kotlin 的空安全在编译时防止空指针异常
3. **不可变性**：使用 `val` 表示不可变变量，`var` 表示可变变量
4. **表达式化**：Kotlin 的 `if` 和 `when` 是表达式，不仅仅是语句
5. **集合**：Kotlin 有不同类型的集合用于不同用例
6. **字符串模板**：Kotlin 的字符串插值比 JavaScript 的更强大
7. **函数重载**：Kotlin 支持函数重载，JavaScript 不支持

## 下一步

在下一个模块中，我们将探索 JVM 生态系统和工具链，包括：
- 理解 JVM 平台
- 使用 Gradle 构建系统
- 包管理和依赖
- IDE 集成和调试工具

这个语法对比的基础将帮助你理解如何有效地将 JavaScript 知识转换为 Kotlin。 